#learn ethers.js

[101blockchainss]

101 Blockchain launched the new Ether.JS Blockchain Developer Course. This tutorial is designed for students to learn how to interact with blockchains via specialized API queries using ethers.js.

[zakjasper]

MEV Bot Development: A Step-by-Step Guide

Introduction

As the DeFi ecosystem grows more complex, MEV (Maximal Extractable Value) bots have become one of the most powerful—and controversial—tools in crypto trading. These bots are designed to extract value from blockchain transactions by reordering, inserting, or censoring transactions in a block. While originally focused on miners, today’s MEV bot development company opportunities are accessible to smart developers who can build bots to interact with protocols like Uniswap, SushiSwap, Curve, and others.

In this step-by-step guide, we’ll walk through the process of developing your own MEV bot—from understanding its core components to writing, simulating, and deploying it.

What Is an MEV Bot?

An MEV bot is an automated trading agent that exploits inefficiencies in blockchain transactions. It aims to maximize profit through techniques such as:

Arbitrage: Buying an asset at a lower price on one DEX and selling it higher on another.

Sandwich Attacks: Placing a buy order before and a sell order after a large user transaction to manipulate price movements.

Liquidation Sniping: Monitoring DeFi lending protocols for vulnerable positions and profiting from liquidations.

These bots monitor the mempool or integrate with services like Flashbots to submit private bundles directly to miners or validators.

MEV Bot Development: A Step-by-Step Guide

Step 1: Understand MEV Fundamentals

Start by learning what Maximal Extractable Value (MEV) means, how it impacts Ethereum and other blockchains, and the types of MEV strategies such as arbitrage, sandwich attacks, and liquidations. Understanding blockchain mechanics, mempool structure, transaction ordering, and frontrunning concepts is critical before development.

Step 2: Choose Your MEV Strategy

Select the specific MEV technique you want to implement—DEX arbitrage, sandwiching, liquidation sniping, or time-bandit attacks. Your choice will determine the logic and external data your bot will need to operate effectively.

Step 3: Set Up Your Development Environment

Install essential tools like Node.js, Hardhat or Foundry, ethers.js or web3.js, and connect to Ethereum mainnet via Infura or Alchemy. Set up Flashbots for private transaction bundling. Use Git and VSCode for development and version control.

Step 4: Monitor Blockchain Data and Mempool

Develop or use an existing script to monitor pending transactions in the mempool using WebSocket or JSON-RPC. For strategies like sandwich or liquidation attacks, listen for large swaps or vulnerable loans, and simulate how your bot should respond.

Step 5: Write the Bot Logic

Create the logic for transaction construction, execution flow, and profit calculation. Include logic for gas estimation, token approvals, smart contract calls, and condition-based execution. Integrate error handling and fallback mechanisms.

Step 6: Simulate and Test on a Forked Network

Use Hardhat or Foundry to fork mainnet and simulate your bot’s transactions in a safe environment. Test for profitability, failed conditions, slippage, and gas efficiency. Refine strategy logic based on simulation results.

Step 7: Integrate Flashbots for Private Execution

To avoid frontrunning and reduce failed transactions, integrate with Flashbots by creating and submitting bundles directly to miners or validators. This helps ensure your transactions are mined in the intended order.

Step 8: Deploy the Bot on Mainnet

Once tested, deploy the bot on the Ethereum mainnet or another supported network. Run it on a secure server or cloud platform. Use cron jobs or real-time triggers to keep the bot active and responsive.

Step 9: Monitor and Optimize Performance

Track your bot’s trade history, gas usage, and success rate. Use dashboards or logging tools for performance monitoring. Continuously optimize strategies by adapting to network changes, gas spikes, and competition from other bots.

Step 10: Stay Updated and Compliant

The MEV landscape evolves quickly. Stay informed through forums, GitHub, and Flashbots research. Monitor ethical debates and legal implications around MEV activities. Consider evolving your bot for multi-chain or L2 MEV opportunities.

What Makes MEV Bots Different from Regular Crypto Bots?

MEV bots differ from regular crypto trading bots in that they extract profits by manipulating the order and timing of on-chain transactions, rather than relying on market trends or exchange arbitrage. While regular bots operate through APIs or smart contracts to execute predefined strategies like scalping or grid trading, MEV bots actively monitor the blockchain’s mempool to exploit inefficiencies such as frontrunning, sandwich attacks, and liquidations. They often use private relayers like Flashbots to submit transaction bundles directly to validators, enabling faster and more secure execution. This makes MEV bots more complex, time-sensitive, and ethically debated compared to traditional trading bots.

Conclusion

A MEV bot development can be highly profitable—but it’s also complex, competitive, and ethically gray. With the right technical knowledge, tools, and strategic insights, developers can enter the world of MEV extraction and participate in the most cutting-edge space in DeFi.

Whether you're building a simple arbitrage bot or a sophisticated front-runner, understanding the Ethereum transaction stack and using Flashbots responsibly is key to long-term success.

[web3developmentservices]

9 Mistakes to Avoid When Learning Web3 Development

As the demand for Web3 development continues to rise in 2025, more developers are exploring this exciting new world of decentralized technologies. However, Web3 is not just another coding skill—it requires a shift in mindset, architecture, and tools.

Whether you're new to blockchain or transitioning from Web2, avoiding common mistakes early can save you time, frustration, and even money. In this article, we’ll break down 9 common mistakes to avoid when learning Web3 development, along with practical advice to get ahead.

1. Skipping Blockchain Fundamentals

Many developers jump straight into coding smart contracts without truly understanding how blockchains work. A solid grasp of consensus mechanisms, transaction flow, gas fees, and blocks is essential.

If you don’t understand the system you’re building on, you’ll likely introduce security flaws or build inefficient applications.

2. Neglecting Smart Contract Security

One of the most critical areas in Web3 development services is smart contract security. Vulnerabilities like reentrancy attacks, integer overflows, or improper access control can cause major losses.

Before deploying anything live:

Study secure development practices

Use auditing tools like Slither or MythX

Learn from past exploit case studies

3. Focusing Only on Ethereum

Ethereum is popular, but it’s not the only chain. Developers should also explore other ecosystems like:

Polygon (Layer 2 scaling)

Solana (high throughput)

BNB Chain

Arbitrum and Optimism (Layer 2 rollups)

Modern Web3 development companies work across multiple chains to optimize performance, fees, and user experience.

4. Ignoring Web2 Skills

Many newcomers believe Web3 requires abandoning traditional web skills. In reality, you still need:

HTML/CSS

JavaScript frameworks like React or Next.js

API integration

A great dApp still needs a solid UI. Web3 solutions that ignore frontend development often end up with poor usability.

5. Not Testing Thoroughly

Failing to test smart contracts and dApps properly is a costly mistake. You should use testnets (like Sepolia, Mumbai, or Fuji) and automated testing tools to catch bugs early.

Use:

Hardhat

Foundry

Truffle

Ganache

Testing is standard practice for every successful Web3 development agency.

6. Underestimating Gas Fees

Gas fees on chains like Ethereum can fluctuate wildly. Writing inefficient code can lead to high execution costs for users.

Web 3.0 developers should optimize smart contracts and understand gas estimation to keep dApps affordable.

7. Not Understanding Token Standards

A good Web 3.0 development company should be familiar with:

ERC-20 (fungible tokens)

ERC-721 (NFTs)

ERC-1155 (multi-token standard)

Knowing when and how to use each standard is essential to creating interoperable Web3 platforms.

8. Skipping Documentation and Community Resources

The Web3 space evolves rapidly. Developers who don’t read documentation or participate in developer forums fall behind quickly.

Stay active on GitHub, Discord, and follow official docs for tools like Ethers.js, Web3.js, and The Graph.

9. Building Without Real-World Use Cases

Many developers jump into projects without solving real problems. Building “just another NFT site” with no unique value won’t succeed.

Study existing Web3 development services and identify how to innovate. Whether it’s finance, gaming, social media, or supply chains—every great project starts with a meaningful problem.

Final Thoughts

Learning Web3 development is rewarding, but it comes with its challenges. By avoiding these 9 common mistakes, you’ll set yourself up for long-term success in the decentralized space.

At Nadcab Labs, we guide startups and enterprises through successful blockchain implementation. Our experienced Web 3.0 developers and security-first mindset ensure that your project is built the right way from the start.

Whether you're building a dApp, NFT platform, or DeFi protocol, we’re here to help.

Visit us here for more:- https://www.nadcab.com/web3-development-services

Get more Blockchain and Web3 Insights with Nadcab Labs

Twitter - twitter.com/nadcablabs

LinkedIn - linkedin.com/company/nadcablabs

Facebook- facebook.com/nadcablabs

Instagram- instagram.com/nadcablabs

YouTube- www.youtube.com/@nadcablabs

[101blockchians]

How do I become an Ethereum developer?

Becoming an Ethereum developer involves acquiring the necessary skills and knowledge to build decentralized applications (dApps) and smart contracts on the Ethereum blockchain. 

Here are the steps you can follow to become an Ethereum developer:

Understand Blockchain Basics:

Start by gaining a solid understanding of blockchain technology, its underlying principles, and how Ethereum fits into the blockchain ecosystem. Study the concepts of decentralization, consensus mechanisms, and smart contracts.

Learn Programming Languages:

Ethereum primarily uses two programming languages for smart contract development:

Solidity

 Vyper

Get Familiar with Ethereum Tools and Libraries:

Ethereum has a rich ecosystem of tools and libraries that simplify development. Some essential ones include:

Truffle

Remix

Web3.js or ethers.js.

Infura or Alchemy

Set Up a Development Environment:

Install and configure the necessary software and tools on your computer. This includes a code editor, a development blockchain network (e.g., Ganache), and the Ethereum client (e.g., Geth or Parity).

Start Building Small Projects:

Begin with simple smart contracts and dApps to apply what you've learned. Experimenting with small projects will help you gain practical experience and confidence.

Study Ethereum Improvement Proposals (EIPs):

Ethereum is continually evolving, and you should keep up to date with the latest proposals and upgrades. EIPs are documents that describe standards, improvements, and new features for Ethereum. Understanding them is crucial for staying current.

Join the Ethereum Community:

Engage with the Ethereum community by participating in forums, attending meetups, and joining relevant online communities (e.g., Reddit's r/ethereum or Ethereum Stack Exchange). Networking with other developers can be invaluable.

Contribute to Open Source Projects:

Consider contributing to open-source Ethereum projects. It's a great way to gain experience, collaborate with other developers, and learn from experts in the field.

Stay Updated:

Stay informed about the latest developments in Ethereum and blockchain technology through blogs, newsletters, podcasts, and conferences.

Build a Portfolio:

As you gain experience, build a portfolio showcasing your projects and contributions. A strong portfolio can help you land Ethereum development jobs or freelance opportunities.

Seek Ethereum Developer Jobs or Freelance Work:

Look for job openings or freelance opportunities in the blockchain and Ethereum development space. Websites like LinkedIn, Ethereum job boards, and freelance platforms can be good places to start your job search.

Keep Learning and Growing:

The blockchain space is continually evolving, so it's essential to keep learning and improving your skills. Consider pursuing advanced topics like DeFi (Decentralized Finance), NFTs (Non-Fungible Tokens), and layer 2 scaling solutions.

Last Words

Remember that becoming a proficient Ethereum developer takes time and dedication. Continuously improving your skills and staying updated with the latest trends and developments in the blockchain industry will set you on the path to success as an Ethereum developer.

Start your journey today to become an Ethereum developer, Enroll now in 101 Blockchains Ethereum Course!

[weekinethereum]

January 25, 2019

News and Links

Layer 1

[eth1] state rent proposal 2

[eth1] selfish mining in Ethereum academic paper. Per Casey Detrio, EIP100 changed the threshold to 27%. But since ETC doesn’t have EIP100, it’s just 5 or 10%.

[eth2] a long AMA from the Eth2 research team

[eth2] yeeth Eth2 client in Swift

[eth2] What’s new in eth2 includes Ben’s take on future of the PoW chain

[eth2] notes from last eth2 implementer call

[eth2] Vitalik’s security design rationale

[eth2] More Vitalik: Eth2 and Casper CBC video talk

[eth2] Collin Myers takes a look at the proposed economics for validators

Layer 2

Raiden on progress towards Ithaca release, which will include pathfinding and fee earning as well as monitoring. More from Loredana on building CryptoBotWars on Raiden

Magmo update: about to release their paper on Nitro, their protocol for a virtual state channel network

The case for Ethereum scaling through layer 2 solutions

Optimistic off-chain data availability from Aragon

Starkware on a layer 2 design fundamental: validity proofs vs fraud proofs. Also: its decentralized exchange using STARKs planned for testnet at end of q1.

Stuff for developers

Solidity v0.5.3

web3j v4.1.1

Web3.js v1.0.0-beta.38

Waffle v2 of its testing suite (uses ethers.js)

Celer Network’s proto3 to solidity library generator for onchain/offchain, cross-language data structures. Celer’s SDK

ERC20 meta transaction wrapper contract

“dumb contracts” that store data in the event logs

ETL pipline on AWS for security token analytics

Interacting with Ethereum using web3.py and Jupyter notebooks

Tutorial on using Embark

Tutorial: using OpenLaw agreements with dapps

OpenBazaar’s escrow framework

Etherisc opensources the code for their Generic Insurance Framework

Austin Griffith’s latest iteration of Burner Wallet sales

Deploying a front end with IPFS and Piñata SDK

Video tutorial of Slither static analyzer

Overview of formal verification projects in Ethereum

zkPoker with SNARks - explore iden3’s circom circuit

Ecosystem

Lots of charts on the bomb historically and present

Gnosis Safe is now available on iOS

A big thing in the community was r/ethtrader’s DONUT tokens. Started by Reddit as “community points” to experiment in ethtrader upvotes, the donuts can be used to buy the banner, vote in polls, and get badges. So a Reddit <> Eth token bridge was created, and DONUT traded on Uniswap. But some people preferred donuts to be used for subreddit governance, so the experiment is currently paused. That’s my take, here’s Will Warren’s take.

Decentralizing project management with the Ethereum Cat Herders

ENS permanent registrar proposals

Client releases

The Mantis client written in Scala now supports ETH and will stop supporting ETC

Enterprise

Hyperledger Fabric founder John Wolpert on why Ethereum is winning in enterprise blockchain

Levi’s jeans, Harvard SHINE and ConsenSys announce a workers well being pilot program at a factory in Mexico

Tokenizing a roomba to charge it

Correctness analysis of Istanbul BFT. Suggests it isn’t and can be improved.

Governance and Standards

Notes from last all core devs call

A postmortem on the Constantinople postponement

SNT community voting dapp v0.1 - quadratic voting system

EIP1712: disallow deployment of unused opcodes

EIP1715: Generalized Version Bits Voting for Consensus Soft and Hard Forks

ERC1723: Cryptography engine standard

ERC1724: confidential token standard

EIP1717: Defuse the bomb and lower mining reward to 1 ether

Application layer

Augur leaderboard. And Crystalball.be stats. Augur v1.10 released

Lots of action in Augur frontends: Veil buys Predictions.global, Guesser to launch Jan 29, and BlitzPredict.

A fiat-backed Korean Won is live on AirSwap

Adventureum - “a text-based, crowd-sourced, decentralised choose-your-own adventure game”

PlasmaBears is live using LoomNetwork

Kyber’s automated price reserve - a simpler though less flexible option for liquidity providers. Also, Kyber’s long-term objectives

Interviews, Podcasts, Videos, Talks

Trail of Bits and ChainSecurity discuss 1283 on Hashing It Out

Videos from Trail of Bits’ Empire Hacking

Scott Lewis and Bryant Eisenbach give the case for Ethereum on a Bitcoin podcast

Philipp Angele talk on Livepeer’s shared economies for video infrastructure

Tarun Chitra on PoS statistical modeling on Zero Knowledge

Gnosis’ Martin Köppelmann on Into the Ether

Martin Köppelmann and Matan Field on Epicenter

Tokens / Business / Regulation

If you don’t have a background in finance, MyCrypto’s learning about supplying and borrowing with Compound will be a good read.

A nice look at the original NFT: CryptoPunk

NFT License 2.0 to define what is permitted with NFT and associated art

IDEO on what NFT collectibles should learn from legacy collectibles.

Matthew Vernon is selling tokens representing 1 hour of design consulting

Caitlin Long tweetstorm about Wyoming’s crypto-friendly legislation

Crypto exchanges don’t need a money transmitter license in Pennsylvania

General

Samsung to have key store in their Galaxy S10. Pictures show Eth confirmed.

Zilliqa to launch its mainnet this week, much like Ethereum launched with Frontier

NEAR’s private testnet launches at event in SF on the 29th

Polkadot upgrades to PoC3 using GRANDPA consensus algo

Looks like Protonmail wants to build on Ethereum

Messari says Ripple drastically overstates their supply to prop up their market cap

Sia’s David Vorick on proof of work attacks

a zero knowledge and SNARKs primer

Infoworld when the Mac launched 35 years ago: do we really need this?

Have a co-branded credit card in the US? Amazon (or whoever) probably gets to see your transaction history, which means they’re probably selling it too.

Dates of Note

Upcoming dates of note (new in bold):

Jan 29-30 - AraCon (Berlin)

Jan 30 - Feb 1 - Stanford Blockchain Conference

Jan 31 - GörliCon (Berlin)

Jan 31 - Maker to remove OasisDEX and Oasis.direct frontends

Feb 2 - Eth2 workshop (Stanford)

Feb 7-8 - Melonport’s M1 conf (Zug)

Feb 7 - 0x and Coinlist virtual hackathon ends

Feb 14 - Eth Magicians (Denver)

Feb 15-17 - ETHDenver hackathon (ETHGlobal)

Feb 27 - Constantinople (block 7280000)

Mar 4 - Ethereum Magicians (Paris)

Mar 5-7 - EthCC (Paris)

Mar 8-10 - ETHParis (ETHGlobal)

Mar 8-10 - EthUToronto

Mar 22 - Zero Knowledge Summit 0x03 (Berlin)

Mar 27 - Infura end of legacy key support

April 8-14 - Edcon hackathon and conference (Sydney)

Apr 19-21 - ETHCapetown (ETHGlobal)

May 10-11 - Ethereal (NYC)

May 17 - Deadline to accept proposals for Instanbul upgrade fork

If you appreciate this newsletter, thank ConsenSys

This newsletter is made possible by ConsenSys.

I own Week In Ethereum. Editorial control has always been 100% me.

If you're unhappy with editorial decisions or anything that I have written in this issue, feel free to tweet at me.

Housekeeping

Archive on the web if you’re linking to it:  http://www.weekinethereum.com/post/182313356313/january-25-2019

Cent link for the night view:  https://beta.cent.co/+3bv4ka

https link: Substack

Follow me on Twitter, because most of what is linked here gets tweeted first: @evan_van_ness

If you’re wondering “why didn’t my post make it into Week in Ethereum?”

Did you get forwarded this newsletter?  Sign up to receive the weekly email

[useful-content-on-internet]

HOW DOES AUTHENTICATION/AUTHORIZATION WORK IN WEB3

With the help of Web3, anyone may utilise the internet for learning and self-improvement in a way that is practical, immersive, open, and accessible. However, if a user wants to interact with the Defi protocol or play blockchain games that take them into the metaverse, Web3 authentication is required. Web3 applications are most likely to fail if they can't log users onto the blockchain. So in order to effectively develop web3 apps or next-generation dApps using blockchain, it must be able to use web3 authentication. Thanks to Web3, users can think of their browser as being more than just a web browser. Also included are DeFi technologies like wallets, which can provide trustworthy user identification for web programmes.

As contrast to centralised systems that track and collect user data, Web3 enables users to identify themselves using public key encryption and blockchain wallets. Users can choose to have many addresses to support a variety of applications or use cases, or they can use protocols like IDX and ENS to link their identity to the address. The owner of an address can be determined using the cryptographic signature. These signatures can be used to sign transactions to a blockchain and decode messages on a web3 library like web3.js and ethers.js. With this approach, web3 authentication and authorization may be finished with very little code.

[aladinsanesworld]

My first NFT Adventure - Part 5 (What I learned)

My heuristic Mondrian Puzzles are all done (deployment does put a very definit stop to further development). They are available at http://mondrian-puzzles.net, where I spend an equal amount of time - if not more - on building a frontend in React using Ethers.js. If you like the puzzles I hope you can find room in your wallet for one and time to see it evolve.

I learned a lot from this adventure. I wanted to lean Solidity, but I as a side effect I learned a lot about:

block chain technology

the various ethereum development environments and processes

how transactions works and what you can derive from the transaction hash

Web3 and Ethers

NodeJS

React

But the biggest challenge was actually putting myself out there and tell and show what I've made. Most of my projects are driven by sheer curiosity or because I see a problem I want to present a solution to.  However I have to push myself to finish them - making the core functionality just isn't enough. The same goes for this project. Making the smart contract was easy, but giving it purpose is something else and promoting it something entirely else.

This goes for almost all my projects. Even when I'm content or proud with my result I don't expect it can be worth anything to anyone but me. I have 80k+ users of my various iOS Apps on AppStore, but only one app is paid - and I really had to twist my own arm in order to charge that one.

Well, this project is over. I don't expect it to sell much, but I hope I can sell enough to cover my direct expenses and my dream is to sell enough to finance a new smart contract project.

Actually I already have an idea (and the core functionality ...). For my next project I'm going to try to combine the smart contract with an off-chain generation to create mosaic based portraits of non-existing persons (!). So stay tuned ;)

[cladeymoore]

Introduction to Building on DeFi with Ethereum and USDC — Part 1

Introduction to Building on DeFi with Ethereum and USDC — Part 1

By Pete Kim

At Coinbase, our mission is to build an open financial system. We strongly believe that increasing economic freedom will make the world a better place. Decentralized Finance, or DeFi for short — an open, borderless, and programmable version of finance — is an inseparable part of that vision.

Smart Contracts

DeFi is powered by smart contracts running on decentralized networks such as Ethereum (“the blockchain”) and digital currencies like USD Coin (USDC), a tokenization of US Dollars on the blockchain. The idea of smart contracts is actually quite simple. Nick Szabo, a pioneer in digital currency and cryptography who originally came up with the idea in 1997 described the vending machine as the ancestor of smart contracts.

The vending machine is an automated version of a contract, expressed in the form of electrical hardware:

You pay the displayed price by inserting money into the machine, the machine dispenses a drink

You don’t pay the displayed price, it doesn’t dispense a drink

If you paid the displayed price but the machine didn’t dispense a drink, or if it dispensed a drink even though you didn’t pay the displayed price, then there is a violation of the contract

The vending machine is able to manage its contractual obligations completely autonomously without human intervention.

Modern smart contracts work the same way, but the contractual clauses are expressed as executable computer code as opposed to being implemented in hardware. The decentralized nature of the network on top of which smart contracts are run ensures that they are executed as written and that no single entity is able to bend the rules or manipulate the outcome. One important caveat is that because the network executes the code verbatim, faulty smart contract code can result in unexpected consequences (“code is law”).

No Better Time Than Now

A lot of people find building on crypto and blockchain very intimidating and think it is only accessible to hard-core computer scientists. While that may have been true as recently as just a few years ago, tooling and developer UX have improved significantly since then, and anyone with basic programming skills can start building (or BUIDLing).

The DeFi ecosystem is currently undergoing explosive growth. USDC reached a $1B market cap in less than 2 years, and the total value of assets stored in various DeFi services blew past $2B in less than 3 years. There really has not been a better time to start developing in this space.

Source: DeFi Pulse

The tutorial below serves as a simple guide to begin developing your own DeFi smart contracts. It is our hope that such a guide will help democratize the creation of a global, open financial system.

Getting Started

This tutorial series assumes that you have some experience with JavaScript, which is the most widely used programming language in the world. You will also be introduced to Solidity, a smart contract programming language used on Ethereum, which is the most widely used smart contract blockchain in the world. Finally, you will get to interact with USDC, the most widely adopted fiat-backed stablecoin in DeFi applications.

Setting up the Development Environment

To get started, we’re going to need a Unix-like environment and Node.js v12.x (the latest LTS release) installed on it. macOS is natively a Unix environment, and Windows users can get it by installing Ubuntu on WSL from the Microsoft Store. More detailed steps can be found here for macOS, and here for Windows. As for the text editor, Visual Studio Code is strongly recommended because the project template you’ll be using comes pre-configured for it, but you can technically use any editor. Oh, and I prefer Vim keybindings over Emacs.

Setting up the Project

It takes some work to set up a Solidity project, and honestly getting distracted by it isn’t very useful for learning at this stage, so a pre-configured template has been prepared for you.

Run the following commands in your terminal to download and setup the template:

$ git clone https://github.com/CoinbaseStablecoin/solidity-tutorial.git $ cd solidity-tutorial $ npm install -g yarn # Install yarn package manager $ yarn # Install project dependencies

You may see some compilation errors as yarn tries to build native extensions. Those are optional and it is safe to ignore the errors. As long as you see the “Done” message at the end, you’re good to go.

Opening the Project in Visual Studio Code

Open the project folder (solidity-tutorial) in Visual Studio Code. The first time the project is open, Visual Studio Code may prompt you to install extensions. Go ahead and click on “Install All”, this will add various useful extensions such as automatic code formatting and Solidity syntax highlighting to the editor.

Creating an Account on Ethereum

Before you can do anything on Ethereum, you need to have an account. Accounts are often called “wallets”, because they can contain digital assets like ETH and USDC. End users typically create accounts by using an Ethereum wallet app like Coinbase Wallet or Metamask, but creating an account programmatically is really simple as well, using the excellent ethers.js library that comes preinstalled with the template.

Create a new JavaScript file called createWallet.js in the src folder, and enter the following code:

https://medium.com/media/f8781695a010c981b1a2cbbc251a9007/href

Save the file, and execute the code using Node.js as follows:

$ node src/createWallet.js

Mnemonic: rabbit enforce proof always embrace tennis version reward scout shock license wing Address: 0xB3512cF013F71598F359bd5CA3f53C1F4260956a

What just happened? Well, you got yourself a brand-spanking new Ethereum account. The “mnemonic” or perhaps more commonly referred to as “recovery phrase” is a human-readable representation of the cryptographic key that is needed to perform actions from the account, and the address is the name and identifier of the account. Copy those down somewhere. On a side note, the mnemonic shown in this post has been slightly altered to discourage you from using it, please use your own!

Think of those as the password and the account number to your bank account, except you could create one in just a few seconds, and you didn’t have to fill out an application form or share any personal information. You can also run this code wherever you are.

⚠️ The account’s mnemonic must be kept a secret. If you lose it, you will lose access to your account and any assets stored in the account forever and no one will be able to help you! Keep it in a safe place!

ℹ️ Technically, you haven’t really “created” an account per se. Instead, what you created was a private/public key pair. If you are curious about what is actually happening under the hood, read about elliptic-curve cryptography, and the Bitcoin and Ethereum specifications BIP39, BIP32, EIP55 and their implementation in this project.

About Gas and Mining

Ethereum is a decentralized network of thousands of computers around the world, and they don’t exactly do work for free. To perform any state change on the blockchain such as storing and updating data, you have to pay the network operators a transaction fee in Ether (ETH), also known as “gas” on Ethereum. This, along with the bonus reward the operators get for adding new blocks to the chain, is what incentivizes them to keep their computers up and running. This process is called “mining” and the network operators are called “miners”. We will be revisiting this later in this tutorial (Gas, Gas Price and Gas Limit).

Obtaining Testnet ETH

Now that you have an account, you should deposit some ETH. We don’t want to waste real money while developing, so we are going to get some fake-ETH meant for developing and testing on the test network (“testnet”) instead. There are many different Ethereum testnets, but we are going to be using Ropsten because of the ease of obtaining test tokens. First, let’s check your current balance using Etherscan, a block explorer for Ethereum. You can do that by entering the following URL in your browser, replacing YOUR_ADDRESS with the address you created earlier, starting with 0x.

https://ropsten.etherscan.io/address/YOUR_ADDRESS

Source: ropsten.etherscan.io

You should see that your balance is 0 ETH. Keep this tab open, and open Ropsten Ethereum Faucet in a different tab. In the faucet page, enter your address and click on the “Send me” button. The transaction may take as little as a few seconds to a minute or two to complete. Check Etherscan again in a bit, and you should see a new balance of 1 ETH and an incoming transaction in the list.

Source: faucet.ropsten.be

Getting ETH Balance Programmatically

Connecting to Ethereum

Using Etherscan to view the balance is useful, but it is also easy to view it with code as well. Before we get back to the code however, we need a way to connect to Ethereum. There are many ways to do it, including running a network node yourself on your computer, but by far the quickest and the easiest way is to do it through a managed node provider such as INFURA or Alchemy. Head over to INFURA, create a free account and create a new project to obtain the API Key (Project ID).

ℹ️ Go Ethereum (“geth”) and Open Ethereum (formerly known as Parity Ethereum) are the two most widely used Ethereum node software.

Viewing ETH Balance with Code

First, let’s write code that reads and derives the account back from the mnemonic. Create a new JavaScript file called wallet.js in the src folder, and enter the following code:

https://medium.com/media/2c97cea6a3de2a220d7a87d67652953d/href

Replace the mnemonic string in the code with your own. Please note that in production code, the mnemonic shouldn’t be hard-coded like that. Instead it should be read from a config file or an environment variable, so that it does not get leaked accidentally for instance by having it checked into a source code repository.

Executing the code, you should be able to see the same address as the one you got earlier:

$ node src/wallet.js

Address: 0xB3512cF013F71598F359bd5CA3f53C1F4260956a

Next, create a new file called provider.js in the same folder. In this file, we will be initializing a provider object with the INFURA API key we obtained earlier. Be sure to replace the API key string with your own:

https://medium.com/media/d5886e6a88f5e63a70fa3d8d8af018a2/href

Finally, we will use both wallet.js and provider.js we created in a new file called getBalance.js in the same folder to get ETH balance:

https://medium.com/media/2fe4daf5d00391ef026ec2f4eaea54db/href

Run the code, and you’ll see your ETH balance!

$ node src/getBalance.js

Address: 0xB3512cF013F71598F359bd5CA3f53C1F4260956a ETH Balance: 1.0

Token Denominations

The code we just created is pretty self-explanatory, but you may be wondering what ethers.utils.formatUnits(balance, 18) does. Well, ETH is actually divisible to 18 decimal places, and the smallest denomination unit is called “wei” (pronounced “way”). In other words, one ETH is equivalent to 1,000,000,000,000,000,000 wei. Another commonly seen denomination is Gwei (pronounced “Giga-way”), which is 1,000,000,000 wei. The getBalance method happens to return the result in wei, so we have to convert it back to ETH by multiplying the result by 10¹⁸. The full list of the denominations can be found here.

ℹ️ You can also use ethers.utils.formatEther(balance), which is a shorthand for ethers.utils.formatUnits(balance, 18).

Obtaining Testnet USDC

The ETH in your account is feeling a little bit lonely, so let’s also get some USDC in it as well. I’ve deployed a pseudo USDC smart contract on the Ropsten testnet. There isn’t a fancy faucet website for it, but the contract contains a function that will give you some free testnet USDC when called. If you navigate to the contract code tab in Etherscan and search for gimmeSome in the contract source code. That is the function we’ll be calling to get some USDC sent to our account.

Making a Transaction to Call a Smart Contract Function

In Ethereum smart contracts there are mainly two types of functions: read-write and read-only. The former may result in a change in the data stored in the blockchain, and the latter purely reads, but never writes. Read-only functions can be called without creating a transaction and therefore without a transaction fee, unless called as part of a read-write function. Read-write functions on the other hand must be called inside a transaction, and the transaction fee (gas) must be paid. Invoking the gimmeSome function results in a change in the USDC balances stored in the blockchain, therefore it has to be called inside a transaction.

Calling a smart contract function requires some extra steps, but it is not too difficult. First, we need to find the full interface of the function we’d like to call, also known as the function signature or the function prototype. Look for gimmeSome again in the contract source code and you will find that the interface is the following:

function gimmeSome() external

It is a really simple function that does not take in any arguments, and it is marked as external, which means that this function can only be called from outside, and not from other functions within this contract. That is OK because we will be calling this function directly in a transaction.

ℹ️ The gimmeSome function does not exist in the “real” USDC contract deployed on the main Ethereum network, for obvious reasons.

Create a new file called getTestnetUSDC.js in the src folder and enter the following code:

https://medium.com/media/3e4d4f75ab9891d3679a8a4b5bc456ff/href

The code first instantiates a contract object (new ethers.Contract) with the interface of the function we are interested in, gimmeSome, and points it at the address of the testnet USDC contract: 0x68ec⋯69c4. You can then call any of the functions you’ve listed. gimmeSome function does not take in any arguments on its own, but you can specify transaction options as the last argument. In this case, we are giving it 20 Gwei of gas price, which should speed up the transaction. All methods that interact with the network are asynchronous in nature and return a Promise, so we are using JavaScript’s await expression. The code then prints the transaction hash, which is a unique identifier of your transaction that can be used to track the progress. It then waits until the transaction is confirmed.

Run the code, and you will see something like the following:

$ node src/getTestnetUSDC.js

Address: 0xB3512cF013F71598F359bd5CA3f53C1F4260956a Transaction hash: 0xd8b4b06c19f5d1393f29b408fc0065d0774ec3b4d11d41be9fd72a8d84cb6208 Transaction confirmed in block 8156350 Gas used: 35121

Voilà! You’ve made your first Ethereum transaction with code! Check your address and the transaction hash in Ropsten Etherscan. You should now see that you now have 10 testnet USDC, and a little less than 1 ETH, due to the gas paid to execute the transaction.

ℹ️ If you inspect the transaction in Etherscan, you will find that it is a transaction that sends zero (0) ETH to the contract address along with 4 bytes of data. If the function call had arguments, there would be more than just 4 bytes of data. If you want to learn about how this data is encoded, read the Ethereum contract ABI specification.

Gas, Gas Price and Gas Limit

Earlier, I mentioned that we are giving the transaction 20 Gwei of gas price to speed up the transaction and the script also prints the amount of gas used. What do all these things mean? Well, Ethereum is a network comprised of network operators. Think of it as a world computer. It is not a free computer though, and every instruction you run on this computer costs money. This computer is also shared by everyone around the world, which means everyone must compete with each other to get their time on this computer.

How do we make this fair? Well, we can auction off time on this computer, and the more you are willing to pay for each compute instruction you run on this computer, the more the network operators (miners) will likely be giving you the time. This sure isn’t perfect, as it could have an effect where only the rich are able to have the privilege of using this system. However it is the least bad solution we have until the system is made much more scalable and can accommodate much more transactions.

Coming back to the blockchain jargon, the “gas used” is the amount of computing resources you’ve consumed as a result of running the transaction and the “gas price” is how much you are willing to pay per unit of gas. In general, the higher you are willing to pay, the higher priority your transaction will have, and the faster it will be confirmed by the network. In our case, we used 20 Gwei as the gas price, and the gas used was 35,121 (you can also find this by inspecting the transaction in Etherscan), so the total gas cost is 35,121 * 20 Gwei = 702,420 Gwei or 0.00070242 ETH.

Since gas costs money, you might want to set an upper limit of the maximum gas you are willing to spend. Luckily, you can set a “gas limit”. If the transaction ends up needing more gas than the gas limit specified, the transaction will fail instead of continuing with the execution and consuming more gas than you’re willing to pay. One side effect to be mindful of is that if the execution ends up failing due to the limit, the amount of gas already spent will not be refunded back to you.

Calling a Smart Contract Function to Read Data

You were able to check that you received 10 USDC on Etherscan, but let’s confirm that by checking the balance with code.

Let’s modify the existing file getBalance.js in the src folder, with the following content:

https://medium.com/media/44386954c26f99b50716c61e90f8da2a/href

USDC is an ERC20 token, so it contains all of the methods defined in the ERC20 specification. balanceOf is one of them, and its interface is taken straight from the spec. balanceOf is a read-only function, so it can be called for free and does not need to be submitted as a transaction. Finally, it is important to note that USDC uses 6 decimal places of precision as opposed to 18 that many other ERC20 tokens use.

ℹ️ You can learn more about Solidity functions here.

Run the code, and now you will see USDC balance as well:

$ node src/getBalance.js

Address: 0xB3512cF013F71598F359bd5CA3f53C1F4260956a ETH Balance: 0.9961879 USDC Balance: 10.0

Transferring ETH and USDC

Now let’s check out how we can spend ETH and USDC we have in our account.

Transferring ETH

Create transferETH.js in the src folder and enter the following code:

https://medium.com/media/f390924136a4743425da3f49e68b467f/href

This code, while lengthier than the previous ones, is really just a combination of everything you’ve learned so far. This script takes in two command line arguments. The first one is the recipient address, and the second is the amount to send. It then ensures that the address provided is valid, the amount provided is not negative and that the account has enough balance to be able to send the amount requested. It then submits the transaction and waits for it to be confirmed.

Create a new account using the createWallet.js script we created earlier, and try sending money to the new address:

$ node src/createWallet.js

Mnemonic: napkin invite special reform cheese hunt refuse ketchup arena bag love caution Address: 0xDdAC089Fe56F0a9C70e6a04C74DCE52F86a91e13

$ node src/transferETH.js 0xDdAC089Fe56F0a9C70e6a04C74DCE52F86a91e13 0.1

Address: 0xB3512cF013F71598F359bd5CA3f53C1F4260956a Transferring 0.1 ETH to 0xDdAC089Fe56F0a9C70e6a04C74DCE52F86a91e13... Transaction hash: 0xa9f159fa8a9509ec8f8afa8ebb1131c3952cb3b2526471605fd84e8be408cebf Transaction confirmed in block 8162896

You can verify the result in Etherscan. Let’s also test that the validation logic works:

$ node src/transferETH.js foo

Address: 0xB3512cF013F71598F359bd5CA3f53C1F4260956a Invalid address: foo

$ node src/transferETH.js 0xDdAC089Fe56F0a9C70e6a04C74DCE52F86a91e13 0.1.2

Address: 0xB3512cF013F71598F359bd5CA3f53C1F4260956a Invalid amount: 0.1.2

$ node src/transferETH.js 0xDdAC089Fe56F0a9C70e6a04C74DCE52F86a91e13 -0.1

Address: 0xB3512cF013F71598F359bd5CA3f53C1F4260956a Invalid amount: -0.1

$ node src/transferETH.js 0xDdAC089Fe56F0a9C70e6a04C74DCE52F86a91e13 100

Address: 0xB3512cF013F71598F359bd5CA3f53C1F4260956a Insufficient balance to send 100.0 (You have 0.89328474)

Transferring USDC

You will be able to use the majority of the code for USDC. The main differences are that USDC has 6 decimal places, and that you have to use the transfer function of the ERC20 spec to perform the transaction. You also pass the arguments “to” and “value” to the transfer smart contract function, rather than the Ethereum transaction itself.

Create transferUSDC.js in the same folder and enter the following:

https://medium.com/media/3f9b8cbd820cdc77b3f2c705c0e0fd35/href

Try it out, it should work just as well:

$ node src/transferUSDC.js 0xDdAC089Fe56F0a9C70e6a04C74DCE52F86a91e13 1

Address: 0xB3512cF013F71598F359bd5CA3f53C1F4260956a Transferring 1.0 USDC to 0xDdAC089Fe56F0a9C70e6a04C74DCE52F86a91e13... Transaction hash: 0xc1b2157a83f29d6c04f960bc49e968a0cd2ef884761af7f95cc83880631fe4af Transaction confirmed in block 8162963

Congratulations!

In this tutorial, you’ve learned how to generate an account, query balance, transfer tokens, and call smart contract functions. You might think that you still don’t know very much about crypto, but you now actually know enough to be able to build your own crypto wallet application. We’ve been writing command-line scripts to keep things simple, but how about building one with a nice web-based graphical interface for homework?

In the next part of this tutorial series, we will write our own Ethereum smart contract from scratch with Solidity and learn how you can build your own coin that is exchangeable with USDC. We’ll also be using the techniques learned today to interact with that contract. Stay tuned.

This website contains links to third-party websites or other content for information purposes only (“Third-Party Sites”). The Third-Party Sites are not under the control of Coinbase, Inc., or its affiliates (collectively, “Coinbase”), and Coinbase is not responsible for the content of any Third-Party Site, including without limitation any link contained in a Third-Party Site, or any changes or updates to a Third-Party Site. Coinbase is not responsible for webcasting or any other form of transmission received from any Third-Party Site. Coinbase is providing these links to you only as a convenience, and the inclusion of any link does not imply endorsement, approval or recommendation by Coinbase of the site or any association with its operators.

The opinions expressed on this website are those of the authors who may be associated persons of Coinbase and who do not represent the views, opinions and positions of Coinbase. Information is provided for general educational purposes only and is not intended to constitute investment or other advice on financial products. Coinbase makes no representations as to the accuracy, completeness, timeliness, suitability, or validity of any information on this website and will not be liable for any errors, omissions, or delays in this information or any losses, injuries, or damages arising from its display or use. Unless otherwise noted, all images provided herein are the property of Coinbase, and all trademarks are the property of their respective owners.

Introduction to Building on DeFi with Ethereum and USDC — Part 1 was originally published in The Coinbase Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.

from Money 101 https://blog.coinbase.com/introduction-to-building-on-defi-with-ethereum-and-usdc-part-1-ea952295a6e2?source=rss----c114225aeaf7---4 via http://www.rssmix.com/

[evanvanness]

Annotated edition, Week in Ethereum News, April 13 issue

The newsletter didn’t get sent until Monday morning, so a bit late for me.  The reason why is that last week I was busy securing the 4 major sponsors necessary to keep this newsletter free for everyone.  Hopefully news on that front will be coming soon.  I’ll be very grateful to the folks who help Week in Ethereum News stay free, and hopefully you will be too.  As I’ve told everyone I talked to, as an editor, the product will remain the exact same.  As a publisher, it’s very important to me that it’s a productive relationship for everyone.

Here’s the most clicked, preserved in a screenshot since my tweets auto-delete

People are excited that the fee market is getting simulated.  This particular piece is probably a bit too simplistic, but Barnabe will be publishing more soon, with more realistic assumptions about endogenous demand.   

People are excited because the fee market change will 1) make it easier for app devs to get their user transactions included and 2) because every transaction will burn some ETH, and 3) it kills economic abstraction forever, something I remember Gavin pushing quite hard in 2015 and 2016.

Meanwhile, Danny published a design on turning off PoW.   Even though it’s long, it’s still rough and just an initial plan.  The focus has been on launching the eth2 chain, but as soon as it is launched, the goal is to turn off the wasteful electricity burn (and issuance!) of PoW.

Eth1

EIP1559 fee market change simulations, assuming demand is exogenous

EVM Bytecode Merklization – merklize code chunks for block witnesses, estimates 40-60% reduction

Some more estimates on code merklization based on recent blocks

One important bit of stateless Ethereum is trying to merklize code chunks to shrink the witness size so that full nodes do not have to hold the full state.  Two different estimates published this week on how important and feasible it is.

Eth2

Bitfly’s explanations of eth2 block explorer charts

PegaSys’s Teku client fully syncs with the Lighthouse testnet

Latest Nimbus client update. Getting up to the multi-client testnet spec, networking improvements, interop ready with Lighthouse

SigmaPrime’s update fuzzing the eth2 clients. Catching bugs, new fuzzing engine

Work on formally verifying the eth2 spec using Dafny

A look at the GUI for Rocketpool’s decentralized staking pool

Aditya’s how FFG is implemented in Eth2 explainer

The clients are all speeding into launching the multi-client testnet.   I suppose the other stuff mostly speaks for itself.

Eth2, post-BeaconChain launch

A design for merging eth1 and eth2 clients to turn off PoW

Better attestation aggregation algos

Verifiable precompiled contracts

An approach for cross-shard transfers at EE level

Perhaps people forget that when Ethereum launched in July 2015, it didn’t actually do anything.  It’ll be the same with Eth2, so on the research front things shifted awhile ago towards all the things necessary to make eth2 work.

Stuff for developers

Solidity v0.6.6 and v0.6.5 – ‘immutable’ new major feature, tuple assignment bugfix, and memory array creation overflow bugfix

Truffle v5.1.21 adds Solidity’s immutable

wighawag’s Buidler Deployment Plugin

Not new, but a comparison of ethers.js and web3js

Example of using web3modal (former web3connect) with vanilla Javascript

MelonJS v1 to interact with Melon’s deployed code

Tool for decoding Ethereum storage

Arrays and maps in Solidity

Yul+ Remix plugin

Chainlink redeployed ETHUSD contract; 2 weeks to migrate from old code

Maintaining offchain NFT data using IPFS

SQL queries on DuneAnalytics tutorial

Django with web3py tutorial

Lots of devs excited about immutable.  

One problem Ethereum has is that everyone prefers RicMoo’s ethers.js yet most people still use web3js because the tutorials push new devs to it.   

Ecosystem

discv5: an explainer of Eth networking’s peer discovery protocol

Eth brand survey

I really appreciate Dean’s networking explainers, I find them quite well-written, and it makes me a little mad that he’s a high school dropout who writes better than I do.  

Enterprise

from the founder of Simple, Sila: payments API to take on ACH

EEA mainnet survey

Hyperledger Besu v1.4.3 – adds eth/65 for better networking, issue found for private transactions created with v1.3.4 and before

Besu now running eth/65 too, which as we found out a few weeks ago, cuts bandwidth usage by a crazy amount.   A nice change from Péter Szilágyi. 

Governance, DAOs, and standards

MakerDAO’s 13 improvement proposals to decentralize governance

TheLAO launches April 28

how to create a bankless DAO

EIP2593: Escalator algo fee market change

This week a lawsuit was filed against Maker.  Personally I think if you’re running to the US courts to bail you out (or assisting that effort) of your use of leverage, then you deserve all the opprobrium that you get.

Application layer

Reddit is rolling out the tokenization of it its karma for more than just r/EthTrader?

Status v1.2, adds Waku to replace Whisper for better messaging

SmokeSignal.eth, post by burning Dai interface prioritizes higher burn

Autumated dollar cost averaging of your stablecoins on Uniswap

Suggestions and programs in Colony

Overview of DxDAO’s Omen prediction markets

Inspect, DeFi transparency registry

Fairmint’s continuous securities offering is live on mainnet

The Reddit thing seems like an unintentional leak, where they were trying to roll it out to just one more community but it got in the app, and now they’re unsure what to do it.   But they’ve been playing with this for years - I believe a job listing first surfaced for a dev to play with this stuff in late 2016 (may have been early 2017)

My weekly DeFi ratio: i’ll call it 3/8 to be DeFi, which is lower than normal.  On the other, the BTC++ could have very easily been in this section (it’s all a bit arbitrary, no?) as well as the 10 Dai use cases post, etc... which would have changed it quite a bit.

Tokens/Business/Regulation

PieDAO’s BTC++ is live on mainnet, a token of comprised of multiple versions of locked/synthetic BTC

Is tokenized BTC on Ethereum good for ETH?

Top 10 use cases of Dai

NFTScribe – attach a message onchain to an NFT while you own it

a16zcrypto: crypto’s biz model isn’t that different but who benefits is

Jesse Walden’s article is now the #2 most clicked - by the time I do the #MostClicked, it’s usually pretty steady, but this time it moved up quite a bit in the subsequent 24 hours.

Betteridge’s Law of Headlines suggests the answer is no, but of course the answer is actually yes.  People using ETH is a good thing, even if it is to speculate on the price of unsustainable memecoins.  It’s impressive how many people are finding different ways to bring the orange memecoin into ETH, using different trust assumptions on BTC side or different use cases.  

Case in point: Atomic Loans did a big push yesterday, where you can lock up BTC and get stablecoins.  Pretty juicy rate to lend at - 9% for USDC and 9.5% for Dai.

General

Chicago DeFi Alliance formed to connect market makers and DeFi startups

CryptoHack: online puzzles to learn cryptography

UTokyo paper on digital courts

You can join the trusted setup ceremony for Semaphore, a zk privacy layer for apps

The CryptoHack site moved up and would have made the most clicked.  Not a shocker that this audience wants to learn more crypto.   Even app devs probably need to learn that the best architecture often involves more crypto and less state storage.

If you haven’t done a trusted setup ceremony, I highly recommend doing one.  Contribute your entropy to the future!   Semaphore is very neat gadget to help app developers be able to add privacy, which is a very needed layer to prevent dystopia.

[101blockchainss]

Ethers.Js Course | 101 Blockchains

At 101 blockchains, browse our new Ethers. js course. If you are new to Ethereum, this tutorial gives you complete guidance from the basic to the advanced level, and our experts will clear all your doubts regarding this.

[101blockchainss]

101 Blockchains has launched its new Ether.Js Blockchain Developer Course recently. This tutorial will help students learn Ethereum dApp development and interact with the blockchain via specialized API queries using ethers.js.

[weekinethereum]

June 28, 2018

News and Links

Protocol

Latest Casper standup call

Buterin: Hash-based VDFs, MIMC and STARKs and Verifiable delay functions and attacks

More Buterin: griefing factor analysis model

Prysmatic’s latest sharding implementation update

Esteban Ordano: Plasmabits. Ethresear.ch writeup of EVM on Plasma chain

Alexey Akhunov: recent data on turbo-geth performance

Mist Browser beta and Ethereum Wallet v0.11.0 release candidate

Stuff for developers

Velma: real time Solidity debugger with VS Code integration

SolidStamp - on-chain registry of code audits

“A definition of purity in the Ethereum EVM with strategies for detecting purity on-chain”

Zero knowledge taxation on Ethereum from QED-it

What we learned contributing to OpenZeppelin

Tutorial on using Puppeth to create a PoA testnet on AWS

Writing WebAssembly by hand

ethereum-abi-ui: generate UI form fields from ABI

Bloom releases developer documentation

uPort overhauls its developer documentation

Simple NodeJS Eth explorer

Solidity, Truffle, NodeJS starter in a Docker image

Metamask passport client - verify token holdings for access

Your first Dharma loan dapp in 5 minutes tutorial

Etherlime: dev framework using ethers.js

web3.Swift v0.3 - native ABI parsing

IBFT explainer for enterprise devs

Ecosystem

Ethereum Name Service: New team, new logo, new roadmap, new workshop/hackathon

Analyzing decentralized exchange activity from Alethio. Cool data viz.

Bankex’s charity water vending machine using NFC

UX challenges in Ethereum - wrapup of post-Edcon UX unconf

Two Ethereum messaging implementations: Melon mail updated and Eth-mail live on Ropsten

Live on mainnet

Status beta is live on mainnet

DAOStack’s Alchemy frontend is deployed to mainnet

Governance and Standards

Enjin blog post on ERC 1155. Gaming NFTs so you can swap many tokens with less gas

ERC1178: Multi-class token standard similar to ERC1155

A different take on NFT composables from Cryptokitties

Project Updates

Livepeer: a path to scaling video transcoding — mining GPUs can transcode video in parallel with only marginal increase in electricity

Updates on the Digix Gold Marketplace

Nice summary of recent Golem AMA

Grid+ gets regulatory approval in Texas to sell electricity

Maker is revamping Oasis dex

Interviews, Podcasts, Videos, Talks

Vlad Zamfir and Vitalik Buterin talk scalability on Hidden Forces

Logan Brutsche talks his new Crypto Primitives Academy on Hashing It Out

London meetup talks: OpenLaw, Incentivai, Ambrosus

Joe Lubin video (and transcript!) on some of the theses that drive ConsenSys

Vanessa Grellet talks social impact on Blockchain Bridge

Paratii’s Felipe Santa Ana The Bitcoin Podcast

Jutta Steiner on fixing the internet with Economist radio

Tokens

Eric Budish NBER working paper: The economic limits of Bitcoin and blockchain. The “model suggests that Bitcoin would be majority attacked if it became sufficiently economically important”

Objective vs subjective TCRs

Incentive alignment in TCRs

Mimicables as token primitive

Token Foundry’s standards for consumer tokens

Vitalik’s estimate of Bitcoin and Ether demand elasticity using historical events

General

EthNews owner Blockchains, LLC pulls back the curtain just a little bit at its massive Northern Nevada industrial park

Sacramento Kings NBA franchise to mine Ether for charity

Brian Armstrong launches GiveCrypto with a 1m donation

a16z announces 300m crypto venture fund

Fortune Q&A with Olaf Carlson-Wee on getting to 1 billion AUM

Facebook lifts its blanket ban on crypto ads

Dates of Note

Upcoming dates of note:

June 25 -- Etherisc token sale starts

June 28 -- BuildEth (San Francisco)

June 30 -- Solidity Gas Golfing challenge deadline

June 30-July1 -- Off the chain state channel workshop (Berlin)

July 6-7 -- TechCrunch blockchain and Ethereum events (Zug)

July 9 -- Augur scheduled to launch

July 12 -- Sharding and Casper workshop with Karl Floersch and Justin Drake (New Delhi)

July 12-18 -- IC3 Eth Bootcamp (Ithaca, NY)

July 14-15 -- Ethereum Magicians governance talks in Berlin

July 19-20 -- DappCon (Berlin)

July 24-26 -- NIFTY hackathon and NFT conference (Hong Kong)

August 3-4 -- Discon (Boulder, CO)

August 10-12 -- EthIndia hackathon (Bangalore)

August 10-12 -- ENS workshop and hackathon (London)

August 22 -- Maker DAO ‘Foundation Proposal’ vote

September 6 -- Security unconference (Berlin)

September 7-9 -- EthBerlin hackathon

September 7-9 -- WyoHackathon (Wyoming)

Oct 5-7 -- TruffleCon in Portland

Oct 5-7 -- EthSanFrancisco hackathon

Oct 22-24 -- Web3Summit (Berlin)

Oct 30 - Nov 2 -- Devcon4 (Prague)

December -- EthSingapore hackathon

If you appreciate this newsletter, thank ConsenSys

I'm thankful that ConsenSys has brought me on and given me time to do this newsletter.

Editorial control is 100% me.  If you're unhappy with editorial decisions, blame me.

Shameless self-promotion

Permalink: http://www.weekinethereum.com/post/175341896433/june-28-2018

Most of what I link to I tweet first: @evan_van_ness

I also have an Ethereum podcast on the Bitcoin Podcast network.

This newsletter is supported by ConsenSys, which is perpetually hiring if you’re interested.

Did someone forward this email to you?  Sign up to receive the weekly email (box in the top blue header)

[weekinethereum]

June 14, 2018

Ethereum News and Links

Protocol

Counterfactual: generalized state channels. Academic paper. Also Jeff Coleman Reddit comment on the history and progress of state channels. The rest of that Reddit thread is worth reading as well.

Tom Close: Minimal Progamable State Channels

Latest Casper standup call

Drake: Committee-based sharded Casper.

Drake: 1-bit BLS aggregation-friendly custody bonds

More Justin Drake: “we are considering changing the Ethereum 2.0 roadmap to skip Casper FFG with 1500 ETH deposits. Instead Casper and sharding validators would be unified from the get-go in the beacon chain, and deposits would be 32 ETH.” Two less technical Reddit threads worth reading: one and two.

Prysmatic’s geth sharding implementation update

Hsiao-Wei Wang: what you can do for sharding slide deck. Nice sharding overview in there as well.

Latest Plasma implementation calls: this week and two weeks ago

an “alternative light-client concept for plasma chain clients”

Dan Robinson: Plasma Debit. payment channels on Plasma Cash?

Loi Luu video talk on Kyber’s Gormos scalability project: application specific “plasma plus sharding”

Ben Jones, Kelvin Fichter: More Viable Plasma

Alexey Akhunov: latest on Turbo-Geth

Stuff for developers

First Vyper beta release

Truper: compile vyper contracts to truffle compatible artifacts.

Karen Scarbrough: A guide to generalized state channels for developers. And part 2.

Connext on becoming a network for projects to open hubs

Human readable contract ABIs using ethers.js

sol2proto  -  Amis’s first step to Contract as a Service

hevm: an EVM implementation for unit testing from Dapphub

ethQL: a graphQL interface from ConsenSys

Loom SDK out in public beta with long update on their plans

dappeteer: e2e testing with Puppeteer + MetaMask

libSTARK: C++ library for Starks from EliBen-Sasson

Thetta DAO framework v0.1. Github repo

Eth dev with Go online guide book

Cryptographic javascript-functions for Ethereum with web3js tutorials

Ecosystem

Slock.it INCUBED client - a network of server nodes for Slockit’s IoT devices

How Weeve puts an Eth wallet in trusted enclave

Latest Open Block Explorers call

John Wolpert on the future of private and public blockchains

Introducing EthIndia and EthBerlin applications are open

Vitalik’s ELI5 on the difference between full and archive nodes

Tips on applying for ECF grants

Releases

Geth v1.8.11: 28% less disk usage, 23% faster block processing, increased memory stability

Governance and Standards

Casey Detrio on what happened to EIP648 (tldr: disk I/O is bottleneck, not CPU)

ERC721 finished last call and is finalized

Dean Eigenmann: against community governance

Avsa: governance of the .ETH namespace and ENS foundation

PoA Network governance model

Project Updates

Augur bounty program opens tomorrow before full launch on July 9

Bloomberg on the Decentraland land rush

Dharma 3 month roadmap: improve dharma.js API, better documentation, standardize terms on some debt agreements

Maker: a Dai primer

Now much easier to pay in tokens like Dai on Gitcoin

How Golem wants to use SGX for computational integrity and privacy

FunFair to seek platform licenses so casino operators don’t have to get their own license

TrustWallet to sell its tokens on Kyber

Brave at 2.7m MAUs and giving away 500k more in BAT

0x’s vision, mission and core values

Andy Warhol work to be auctioned by Maecenas

Interviews, Podcasts, Videos, Talks

Truebit’s Harley Swick on Hashing It Out

Grigore Rosu talks K framework on Epicenter

Joey Krug with Laura Shin

5 mins of Joey Krug’s story of risktaking leading him to Augur

Meher Roy gets interviewed by Decrypt Asia

Glen Weyl lecture on Radical Markets at Google

Video of Kyber Network’s event last week

Griff Green revisits The DAO on Zero Knowledge

Tokens

SEC’s William Hinman: “current offers and sales of Ether are not securities transactions.”

CFTC Commissioner Rostin Behnam: “Blockchain is more than technology: it is an advance that reaches out into every aspect of life.”

Colony’s Hackathon is an MVP of perpetual inflation to incentivize developers.

Etherisc: democratizing insurance using blockchain

A compendium of NFT links

Ujo: expanding collectibles for artists

Incentivized music curation with curved bonding rewards

What if BitTorrent had a token? More lessons learned from p2p file sharing by John Backus

General

Leigh Cuen reports on Code to Inspire offering Afghan women opportunities to earn Eth for completing tasks

How Polkadot is addressing the big issues in blockchain

Academic paper claiming Bitfinex/Tether manipulated Bitcoin price. I skimmed and did not see reason to update my priors. Still maybe.

Coinbase Index Fund is now open.

VB answers a few technical questions on Marginal Revolution.

Irish newspaper interviews Joe Lubin

Discussion of 20 psychological biases around money that is getting passed around in crypto circles this last week

A year after the sale, Tezos adds KYC/AML

WSJ on big pharma companies tracking supply chains using Ethereum.

Dates of Note

Upcoming dates of note:

June 24 -- Colony online hackathon finishes

June 25 -- Etherisc token sale starts

June 28 -- BuildEth (San Francisco)

June 30 -- Solidity Gas Golfing challenge deadline

June 30-July1 -- Off the chain state channel workshop (Berlin)

July 6-7 -- TechCrunch blockchain and Ethereum events (Zug)

July 9 -- Augur scheduled to launch

July 12-18 -- IC3 Eth Bootcamp (Ithaca, NY)

July 14-15 -- FEM governance meetings in Berlin

July 19-20 -- DappCon (Berlin)

July 24-26 — NIFTY hackathon and NFT conference (Hong Kong)

August 3-4 -- Discon (Boulder, CO)

August 10-12 -- EthIndia hackathon (Bangalore)

September 6 -- Security unconference (Berlin)

September 7-9 -- EthBerlin hackathon

September 7-9 -- WyoHackathon (Wyoming)

Oct 5-7 -- TruffleCon in Portland

Oct 5-7 -- EthSanFrancisco hackathon

Oct 22-24 -- Web3Summit (Berlin)

Oct 30 - Nov 2 -- Devcon4 (Prague)

December -- EthSingapore hackathon

If you appreciate this newsletter, thank ConsenSys

I'm thankful that ConsenSys has brought me on and given me time to do this newsletter.

Editorial control is 100% me.  If you're unhappy with editorial decisions, blame me.

Shameless self-promotion

Here’s the link to share:  http://www.weekinethereum.com/post/174893922173/june-14-2018

Most of what I link to I tweet first: @evan_van_ness

This newsletter is supported by ConsenSys, which is perpetually hiring if you’re interested.

Did someone forward this email to you?  Sign up to receive the weekly email (text box in the top blue header)

[weekinethereum]

October 19, 2018

News and Links

Protocol

[Eth 2.0] What’s new in Eth 2.0 weekly

[Eth 2.0] Eric Conner’s economics of staking, with Vitalik adding some numbers.

[Eth 2.0] Improvements to reduce capital costs of being a Casper validator

[Eth 2.0] Prysmatic’s biweekly update

[Eth 2.0] Notes from last Eth2.0 implementer call

[Eth 2.0] Ben Edgington’s London talk slides, slightly different from last week’s Paris slides

[Plasma] Georgios Konstantopoulos: Towards more efficient Plasma Cash constructions

[Plasma] Log(coins)-sized proofs of inclusion and exclusion for RSA accumulators

[State channels] Last two state channel researcher calls. Call #5 and call #4

[ewasm] Alex Beregszaszi and Lane Rettig talk ewasm with Jake Brukhman

Stuff for developers

Prepare your dapp for optional web3 injection (eip1102)

Ethers.js v4.0 - rewritten in TypeScript; better ENS support, events emitter, event filters, etc

EtherLime using ether.js v4 and solc v.0.4.25; 40% code coverage on CLI and 100% on API

Buidler - first Ethereum task runner

Truffle on Azure

web3x v1.1 - web3js in Typescript. Also, EVM in Typescript

Poor man’s DecodeABI in Solidity from Austin Griffith

Pixura’s GraphQL API for NFTs

Multicall - group multiple calls into a single call and aggregate results

Connext’s post-mortem on the SpankChain hack, plus Docker images of their hubs

Messaging in Raiden and why they chose Matrix. Also testnet v0.14

Mind Breed - a Brainfuck interpreter where you have to sacrifice a CryptoKitty to add an instruction

Matryx wrote its code in Yul/Julia to save on gas

Preview of Formality language featuring formal proofs from Victor Maia

Deprecation of v0.5 Aragon DAOs on Rinkeby

web3j Gradle plugin for Java, Kotlin and Android devs

Get server-side rendering benefits without building SSR logic

Zeppelin on EVM packages: re-usable, upgradeable, on-chain code. available in ZeppelinOS and AragonOS

Slither - Solidity static analysis framework from Trail of Bits

Client releases

Parity 2.0.8 stable and 2.13 beta- with Constantinople bug fix

Ecosystem

Round 4 of Ethereum Foundation grants

Mastering Ethereum by Andreas Antonopoulos to start shipping end of Nov

Kelvin Fichter: looking at ownership in the EVM

Lessons learned squatting ENS domains

Print your NFT onto schwag

Mixeth - paper on trustless coinmixing service

Enterprise

Quorum v2.1.1

What EEA & Hyperledger collaboration means for enterprise blockchain. EEA spec 2.0 coming at Devcon

Adhara announces Santander’s Julio Faura and Deutsche Bank’s Ed Budd have joined, plus 15m in ConsenSys funding to work on international payments with central banks

Governance and Standards

Latest core devs call on Constantinople fork. Per the notes, the fork is pushed to next year

Lane Rettig’s writeup of the Ropsten testnet consensus failure for Constantinople. Interesting real world stress test, but on a testnet.

Talk of a KEVM client for consensus tests to build on the JelloPaper of the EVM in K

AGP1 - vote on Aragon’s governance process on Nov 15

ERC1497: Evidence standard

ERC1484: Digital identity aggregator

ERC1511: Manager token standard

ERC1504: Upgradeable standard

ERC1505: Token forwarding

ERC1513: Refungible ERC721 Asset with Fungible ERC20

Project Updates

RocketPool’s plans for its Eth2.0 staking pool

Celer on lessons learned at EthSF testing its Gomoku dapp running on its state channels. I tried it, very cool. Possibly too addictive, since I’m bad at it.

CryptoCup’s NFL prediction game is live

MyCrypto v1.4

Ujo officially debuts collectible patronage badges for musicians

Brave releases new Chromium based version that is 20% faster.

iExec’s end to end SGX solution

Civil failed to reach its minimum threshold; says it will do another sale “in weeks”

A first look at the Grid+ Lattice hardware wallet

Maker & POANet launch xDai sidechain. Lots of Tether drama led to lots of stablecoin fluctuations, but Dai stayed steady.

Peepeth is now free

Colony Q3 update - all the stuff they’re working on; Q4 launch planned

Interviews, Podcasts, Videos, Talks

Print Q&A with Brave’s Yan Zhu

Latest Open Source Block Explorers call

Around the Block, episode 3

Infura’s Michael Wuehler talk on scaling Eth to 11b requests a day

Glen Weyl on Hashing It Out

MyCrypto’s Jordan Spence on Boost podcast

Celer Network’s Mo Dong layer 2 mechanism design talk

Liquidity Network’s Arthur Gervais on Smartest Contract

New 51% podcast. Recent episodes with Rune Christenesen and Andrew Keys

Numerai’s Richard Craib on Zero Knowledge

Gitcoin’s Kevin Owocki on Epicenter

Starkware’s Michael Riabzev's talk on STARKs

Tokens / Business / Regulation

John Backus: private bittorrent trackers are loosely a market.  Or a protocol token?

SEC opens a “fintech hub” to communicate with their staff.

Entire remarks of CFTC Commish Quintenz arguing devs should be liable for their code. The compliance cost would be devastating and a massive dead weight loss for society.

Worker selection algos for work tokens

General

The New Yorker on the early days of Ethereum. Solid work. In the same vein, a solid history of Augur

Zexe: enabling decentralized private computation. “think of it as a fully private state channel where each transition can be checkpointed/validated on chain”

Geth is the on the top 10 list of fastest growing projects on Github

GDAX head Adam White joins Bakkt as COO

Steve Wozniak joins tokenized VC fund Equi

Fidelity Digital Assets launches ETH/BTC custody and execution for institutions

Dates of Note

Upcoming dates of note (new additions in bold):

Oct 22-24 - Web3Summit (Berlin)

Oct 24-25 - Winding Tree hackathon (Prague)

Oct 26-28 - Status hackathon (Prague)

Oct 29 - Decentralized Insurance D1Conf (Prague)

Oct 29 - Swarm mini-summit (Prague)

Oct 29 - Ethereum Magicians Council of Prague

Oct 30 - Nov 2 - Devcon4 (Prague)

Nov 1 - Blockchains LLC launch event (Prague)

Nov 2 - MetaMask, Mist, imToken and Status to stop injecting web3

Nov 3-4 - Enterprise Ethereum hackathon (Prague)

Dec 7-9 - ETHSingapore hackathon

Jan 10 - Mobi Grand Challenge hackathon ends

Jan 29-30 - AraCon (Berlin)

Feb 15-17 - ETHDenver hackathon

If you appreciate this newsletter, thank ConsenSys

This newsletter is made possible by ConsenSys, which is perpetually hiring if you’re interested.

I own Week In Ethereum. As such, editorial control has always been 100% me.  If you're unhappy with editorial decisions, feel free to tweet at me.

Shameless self-promotion

Link: http://www.weekinethereum.com/post/179257658573/october-19-2018

Most of what I link to I tweet first: @evan_van_ness

Did someone forward this email to you?  Sign up to receive the weekly email (box in the top blue header)